// parking_commands.c
#include <stdio.h>            // 标准输入输出函数
#include <string.h>           // 字符串处理函数
#include <time.h>             // 时间处理函数
#include <pthread.h>          // 线程库函数
#include <stdlib.h>           // 标准库函数（内存分配、随机数等）
#include "cJSON.h"            // JSON解析库
#include "parking_commands.h" // 命令处理头文件
#include "parking_network.h"  // 网络通信头文件
#include "parking_hardware.h" // 硬件控制头文件

// 在 parking_commands.c 中添加 UI 更新回调支持
// static ui_update_callback_t g_ui_update_callback = NULL;

// 全局数据定义
parking_data_t parking_data; // 全局停车场数据结构体
// 保持原有的 data_mutex 定义
static pthread_mutex_t data_mutex = PTHREAD_MUTEX_INITIALIZER; // 数据互斥锁，保护共享数据

// 初始化默认数据
void initialize_default_data(void)
{
    pthread_mutex_lock(&data_mutex); // 加锁，保护共享数据

    // 设置默认数据 - 保持您原有的初始化值
    memset(&parking_data, 0, sizeof(parking_data_t)); // 清零整个结构体

    // 基础停车数据初始化
    parking_data.total_spaces     = 500; // 总车位数
    parking_data.available_spaces = 325; // 可用车位数
    parking_data.occupied_spaces  = 175; // 已用车位数
    parking_data.utilization_rate = 35;  // 利用率35%

    // 环境数据初始化
    parking_data.temperature = 25;  // 温度25度
    parking_data.humidity    = 60;  // 湿度60%
    parking_data.light_level = 450; // 光照强度450
    parking_data.air_quality = 75;  // 空气质量75

    // 车辆进出统计初始化
    parking_data.vehicles_in      = 1245; // 今日进场1245辆
    parking_data.vehicles_out     = 1198; // 今日出场1198辆
    parking_data.vehicles_current = 47;   // 当前在场47辆

    // 时间相关数据
    parking_data.timestamp      = time(NULL); // 当前时间戳
    parking_data.peak_hour_flag = 0;          // 非高峰时段

    // 地下1层数据
    parking_data.floor_b1_total       = 200; // 总车位200个
    parking_data.floor_b1_available   = 50;  // 可用50个
    parking_data.floor_b1_utilization = 75;  // 利用率75%

    // 地下2层数据
    parking_data.floor_b2_total       = 150; // 总车位150个
    parking_data.floor_b2_available   = 60;  // 可用60个
    parking_data.floor_b2_utilization = 60;  // 利用率60%

    // 地下3层数据
    parking_data.floor_b3_total       = 150; // 总车位150个
    parking_data.floor_b3_available   = 22;  // 可用22个
    parking_data.floor_b3_utilization = 85;  // 利用率85%

    // 客户行为分析数据
    parking_data.avg_parking_time_x100 = 250;  // 平均停车2.5小时（x100倍）
    parking_data.avg_consumption_x100  = 4560; // 平均消费45.6元（x100倍）
    parking_data.member_ratio          = 68;   // 会员比例68%

    // 停车时长分布
    parking_data.parking_time_less_1h = 35; // <1小时：35%
    parking_data.parking_time_1_2h    = 20; // 1-2小时：20%
    parking_data.parking_time_2_4h    = 20; // 2-4小时：20%
    parking_data.parking_time_more_4h = 25; // >4小时：25%

    // 车牌识别数据
    parking_data.recognized_vehicles    = 1245; // 已识别1245辆
    parking_data.unrecognized_rate_x100 = 230;  // 未识别率2.3%（x100倍）
    parking_data.vehicle_type_truck     = 560;  // 货车560辆
    parking_data.vehicle_type_suv       = 374;  // SUV 374辆
    parking_data.vehicle_type_car       = 311;  // 轿车311辆

    // 客户反馈数据
    strncpy(parking_data.common_feedback, "车位不足", sizeof(parking_data.common_feedback) - 1); // 常见反馈
    parking_data.common_feedback[sizeof(parking_data.common_feedback) - 1] = '\0';               // 确保字符串结束

    parking_data.avg_waiting_time_x100 = 850; // 平均等待8.5分钟（x100倍）
    parking_data.facility_score_x100   = 450; // 设施评分4.5分（x100倍）
    parking_data.service_score_x100    = 430; // 服务评分4.3分（x100倍）
    parking_data.satisfaction_score    = 90;  // 总体满意度90分

    // 高峰时段数据（各小时车流量）
    parking_data.hour_6_count  = 20;  // 6点：20辆
    parking_data.hour_8_count  = 120; // 8点：120辆
    parking_data.hour_10_count = 80;  // 10点：80辆
    parking_data.hour_12_count = 40;  // 12点：40辆
    parking_data.hour_14_count = 60;  // 14点：60辆
    parking_data.hour_16_count = 100; // 16点：100辆
    parking_data.hour_18_count = 130; // 18点：130辆
    parking_data.hour_20_count = 70;  // 20点：70辆

    pthread_mutex_unlock(&data_mutex); // 解锁

    printf("Default parking data initialized\n"); // 初始化完成提示
}

// 保持原有的handle_led_control函数
void handle_led_control(const char * action, const char * target, int value, const char * request_id)
{
    // 打印LED控制参数信息
    printf("LED Control - action: %s, target: %s, value: %d\n", action ? action : "NULL", target ? target : "NULL",
           value);

    // 处理开关操作（on/off）
    if(strcmp(action, "on") == 0 || strcmp(action, "off") == 0) {
        int led_state = (strcmp(action, "on") == 0) ? LED_ON : LED_OFF; // 确定LED状态

        // 控制所有LED
        if(target && strcmp(target, "all") == 0) {
            control_all_leds(led_state); // 控制所有LED
            if(request_id) {
                // 发送成功响应
                network_send_command_response(request_id, "success",
                                              led_state == LED_ON ? "All LEDs turned ON" : "All LEDs turned OFF");
            }
        }
        // 通过目标名称控制单个LED（如"1", "2", "3", "4"）
        else if(target && target[0] >= '1' && target[0] <= '4') {
            int led_num = target[0] - '0';   // 字符转数字
            control_led(led_num, led_state); // 控制指定LED
            if(request_id) {
                network_send_command_response(request_id, "success",
                                              led_state == LED_ON ? "LED turned ON" : "LED turned OFF");
            }
        }
        // 通过数值控制单个LED（1-4）
        else if(value >= 1 && value <= 4) {
            control_led(value, led_state); // 控制指定LED
            if(request_id) {
                network_send_command_response(request_id, "success",
                                              led_state == LED_ON ? "LED turned ON" : "LED turned OFF");
            }
        } else {
            printf("Invalid LED target or value\n"); // 无效的目标或值
            if(request_id) {
                network_send_command_response(request_id, "error", "Invalid LED target or value"); // 发送错误响应
            }
        }
    }
    // 处理闪烁操作
    else if(strcmp(action, "blink") == 0) {
        int times = (value > 0) ? value : 3; // 闪烁次数，默认3次
        blink_leds(times, 500);              // 闪烁LED，间隔500ms
        if(request_id) {
            network_send_command_response(request_id, "success", "LEDs blinked"); // 发送成功响应
        }
    }
    // 未知操作
    else {
        printf("Unknown LED action: %s\n", action); // 未知操作提示
        if(request_id) {
            network_send_command_response(request_id, "error", "Unknown LED action"); // 发送错误响应
        }
    }
}

// 保持原有的数据访问函数
// 在 parking_commands.c 的 get_parking_data 函数中添加调试信息
void get_parking_data(parking_data_t * dest)
{
    pthread_mutex_lock(&data_mutex);                     // 加锁保护共享数据
    memcpy(dest, &parking_data, sizeof(parking_data_t)); // 复制数据到目标地址
    pthread_mutex_unlock(&data_mutex);                   // 解锁

    // 添加调试输出
    // printf("=== get_parking_data called ===\n");
    // printf("total_spaces: %d\n", dest->total_spaces);
    // printf("available_spaces: %d\n", dest->available_spaces);
    // printf("vehicles_in: %d\n", dest->vehicles_in);
    // printf("vehicles_out: %d\n", dest->vehicles_out);
    // printf("temperature: %d\n", dest->temperature);
    // printf("humidity: %d\n", dest->humidity);
    // printf("===============================\n");
}

// 在 parking_commands.c 中修改 update_parking_data 函数
void update_parking_data(parking_data_t * new_data)
{
    pthread_mutex_lock(&data_mutex);                         // 加锁保护共享数据
    memcpy(&parking_data, new_data, sizeof(parking_data_t)); // 更新全局数据
    pthread_mutex_unlock(&data_mutex);                       // 解锁

    // 打印更新信息
    // printf("Parking data updated - total: %d, available: %d\n", new_data->total_spaces, new_data->available_spaces);

    // 注意：这里不能直接调用UI回调，因为g_ui_update_callback在interface_display.c中
    // UI更新应该通过其他机制触发，比如在network_tcp_client_thread中
}

// 处理蜂鸣器控制命令
void handle_buzzer_control_command(cJSON * paras_item, const char * request_id)
{
    if(!paras_item) {                                                        // 检查参数是否存在
        printf("❌ ERROR: No parameters found in buzzer_control command\n"); // 错误提示
        if(request_id) {
            network_send_command_response(request_id, "error", "No parameters provided"); // 发送错误响应
        }
        return; // 直接返回
    }

    // 解析参数
    cJSON * action_item = cJSON_GetObjectItem(paras_item, "action"); // 获取action参数
    cJSON * value_item  = cJSON_GetObjectItem(paras_item, "value");  // 获取value参数

    char * action = (action_item && cJSON_IsString(action_item)) ? action_item->valuestring : NULL; // 提取action字符串
    int value     = (value_item && cJSON_IsNumber(value_item)) ? value_item->valueint : -1;         // 提取value数值

    // 打印参数信息
    printf("🔧 Buzzer Parameters:\n");
    printf("  Action: %s\n", action ? action : "NULL");
    printf("  Value: %d\n", value);

    if(action) {                        // 检查action是否存在
        if(strcmp(action, "on") == 0) { // 开启蜂鸣器
            printf("🔊 Turning buzzer ON\n");
            control_buzzer(BUZZER_ON); // 控制蜂鸣器开启
            if(request_id) {
                network_send_command_response(request_id, "success", "Buzzer turned ON"); // 发送成功响应
            }
        } else if(strcmp(action, "off") == 0) { // 关闭蜂鸣器
            printf("🔇 Turning buzzer OFF\n");
            control_buzzer(BUZZER_OFF); // 控制蜂鸣器关闭
            if(request_id) {
                network_send_command_response(request_id, "success", "Buzzer turned OFF"); // 发送成功响应
            }
        } else if(strcmp(action, "alarm") == 0) { // 报警模式
            int times = (value > 0) ? value : 3;  // 报警次数，默认3次
            printf("🚨 Activating buzzer alarm: %d times\n", times);
            buzzer_alarm(times, 500); // 触发蜂鸣器报警
            if(request_id) {
                network_send_command_response(request_id, "success", "Buzzer alarm activated"); // 发送成功响应
            }
        } else if(strcmp(action, "continuous") == 0) { // 持续模式
            int duration = (value > 0) ? value : 5;    // 持续时间，默认5秒
            printf("🔊 Activating continuous buzzer: %d seconds\n", duration);
            buzzer_continuous_alarm(duration); // 触发持续蜂鸣
            if(request_id) {
                network_send_command_response(request_id, "success", "Continuous buzzer activated"); // 发送成功响应
            }
        } else { // 未知操作
            printf("❌ ERROR: Unknown buzzer action: %s\n", action);
            if(request_id) {
                network_send_command_response(request_id, "error", "Unknown buzzer action"); // 发送错误响应
            }
        }
    } else { // 缺少action参数
        printf("❌ ERROR: No action specified for buzzer control\n");
        if(request_id) {
            network_send_command_response(request_id, "error", "No action specified"); // 发送错误响应
        }
    }
}

// 处理LED控制命令
void handle_led_control_command(cJSON * paras_item, const char * request_id)
{
    if(!paras_item) {                                                     // 检查参数是否存在
        printf("❌ ERROR: No parameters found in led_control command\n"); // 错误提示
        if(request_id) {
            network_send_command_response(request_id, "error", "No parameters provided"); // 发送错误响应
        }
        return; // 直接返回
    }

    // 解析参数
    cJSON * action_item = cJSON_GetObjectItem(paras_item, "action"); // 获取action参数
    cJSON * target_item = cJSON_GetObjectItem(paras_item, "target"); // 获取target参数
    cJSON * value_item  = cJSON_GetObjectItem(paras_item, "value");  // 获取value参数

    char * action = (action_item && cJSON_IsString(action_item)) ? action_item->valuestring : NULL; // 提取action
    char * target = (target_item && cJSON_IsString(target_item)) ? target_item->valuestring : NULL; // 提取target
    int value     = (value_item && cJSON_IsNumber(value_item)) ? value_item->valueint : -1;         // 提取value

    // 打印参数信息
    printf("🔧 LED Parameters:\n");
    printf("  Action: %s\n", action ? action : "NULL");
    printf("  Target: %s\n", target ? target : "NULL");
    printf("  Value: %d\n", value);

    handle_led_control(action, target, value, request_id); // 调用LED控制函数
}

// 处理显示数据更新命令
void handle_update_display_data_command(cJSON * paras_item, const char * request_id)
{
    if(!paras_item) {                                                             // 检查参数是否存在
        printf("❌ ERROR: No parameters found in update_display_data command\n"); // 错误提示
        if(request_id) {
            network_send_command_response(request_id, "error", "No parameters provided"); // 发送错误响应
        }
        return; // 直接返回
    }

    // 解析参数
    cJSON * data_type_item = cJSON_GetObjectItem(paras_item, "data_type"); // 获取数据类型参数
    cJSON * new_value_item = cJSON_GetObjectItem(paras_item, "new_value"); // 获取新值参数

    char * data_type =
        (data_type_item && cJSON_IsString(data_type_item)) ? data_type_item->valuestring : NULL;        // 提取数据类型
    int new_value = (new_value_item && cJSON_IsNumber(new_value_item)) ? new_value_item->valueint : -1; // 提取新值

    // 打印参数信息
    printf("🔧 Display Update Parameters:\n");
    printf("  Data Type: %s\n", data_type ? data_type : "NULL");
    printf("  New Value: %d\n", new_value);

    // 验证参数有效性
    if(!data_type || new_value == -1) {
        printf("❌ ERROR: Invalid parameters for update_display_data\n"); // 参数无效提示
        if(request_id) {
            network_send_command_response(request_id, "error",
                                          "Invalid parameters: data_type and new_value are required"); // 发送错误响应
        }
        return; // 直接返回
    }

    // 获取当前数据
    parking_data_t current_data;
    get_parking_data(&current_data); // 从全局存储获取当前数据

    // 打印更新前数据状态
    // printf("📊 Current Data Before Update:\n");
    // printf("  total_spaces: %d\n", current_data.total_spaces);
    // printf("  floor_b1_total: %d\n", current_data.floor_b1_total);
    // printf("  floor_b2_total: %d\n", current_data.floor_b2_total);
    // printf("  floor_b3_total: %d\n", current_data.floor_b3_total);
    // printf("  facility_score_x100: %d (%.1f/5)\n", current_data.facility_score_x100,
    //        current_data.facility_score_x100 / 100.0);
    // printf("  service_score_x100: %d (%.1f/5)\n", current_data.service_score_x100,
    //        current_data.service_score_x100 / 100.0);
    // printf("  satisfaction_score: %d\n", current_data.satisfaction_score);

    char response_msg[128]; // 响应消息缓冲区
    int update_success = 1; // 更新成功标志

    // else if(strcmp(data_type, "floor_b1_total") == 0) {                             // 更新地下1层车位数
    //     current_data.floor_b1_total = new_value;
    //     snprintf(response_msg, sizeof(response_msg), "地下1层车位数更新为 %d", new_value);
    //     printf("✅ SUCCESS: Updated floor_b1_total to %d\n", new_value);
    // } else if(strcmp(data_type, "floor_b2_total") == 0) { // 更新地下2层车位数
    //     current_data.floor_b2_total = new_value;
    //     snprintf(response_msg, sizeof(response_msg), "地下2层车位数更新为 %d", new_value);
    //     printf("✅ SUCCESS: Updated floor_b2_total to %d\n", new_value);
    // } else if(strcmp(data_type, "floor_b3_total") == 0) { // 更新地下3层车位数
    //     current_data.floor_b3_total = new_value;
    //     snprintf(response_msg, sizeof(response_msg), "地下3层车位数更新为 %d", new_value);
    //     printf("✅ SUCCESS: Updated floor_b3_total to %d\n", new_value);
    // }

    // 根据数据类型更新对应的字段
    if(strcmp(data_type, "total_spaces") == 0) { // 更新总车位数
        current_data.total_spaces = new_value;
        snprintf(response_msg, sizeof(response_msg), "总车位数更新为 %d", new_value); // 格式化响应消息
        printf("✅ SUCCESS: Updated total_spaces to %d\n", new_value);                // 成功提示
    }  else {                                                                             // 不支持的数据类型
        snprintf(response_msg, sizeof(response_msg), "不支持的数据类型: %s", data_type); // 错误消息
        update_success = 0;                                                              // 标记更新失败
        printf("❌ ERROR: Unsupported data_type: %s\n", data_type);                      // 错误提示
    }

    if(update_success) { // 如果更新成功
        // 更新数据并触发UI刷新
        update_parking_data(&current_data); // 更新全局数据

        // 打印更新后数据状态
        // printf("📊 Data After Update:\n");
        // printf("  total_spaces: %d\n", current_data.total_spaces);
        // printf("  floor_b1_total: %d\n", current_data.floor_b1_total);
        // printf("  floor_b2_total: %d\n", current_data.floor_b2_total);
        // printf("  floor_b3_total: %d\n", current_data.floor_b3_total);
        // printf("  facility_score_x100: %d (%.1f/5)\n", current_data.facility_score_x100,
        //        current_data.facility_score_x100 / 100.0);
        // printf("  service_score_x100: %d (%.1f/5)\n", current_data.service_score_x100,
        //        current_data.service_score_x100 / 100.0);
        // printf("  satisfaction_score: %d\n", current_data.satisfaction_score);

        // printf("🔄 Triggering UI update...\n"); // UI更新提示

        // 手动触发UI更新
        // parking_data_t updated_data;
        // get_parking_data(&updated_data); // 获取更新后的数据
        // update_ui_with_data(&updated_data); // 更新UI显示

        // 只使用异步更新
        parking_data_t * data_copy = malloc(sizeof(parking_data_t));
        if(data_copy) {
            get_parking_data(data_copy);
            lv_async_call(async_ui_update, data_copy);
        }

        printf("✅ SUCCESS: Data updated and UI refreshed\n"); // 成功提示

        if(request_id) {
            network_send_command_response(request_id, "success", response_msg); // 发送成功响应
        }
    } else {                                       // 更新失败
        printf("❌ FAILED: Data update failed\n"); // 失败提示
        if(request_id) {
            network_send_command_response(request_id, "error", response_msg); // 发送错误响应
        }
    }
}

// 保持原有的handle_server_command函数
void network_handle_server_command(const char * command_data)
{
    printf("\n=== COMMAND PROCESSING START ===\n"); // 命令处理开始
    printf("Raw command data: %s\n", command_data); // 打印原始命令数据

    // 解析JSON命令
    cJSON * root = cJSON_Parse(command_data);                            // 解析JSON字符串
    if(!root) {                                                          // 解析失败
        printf("❌ ERROR: Failed to parse command JSON\n");              // 错误提示
        printf("Command data that failed to parse: %s\n", command_data); // 打印失败数据
        return;                                                          // 直接返回
    }
    printf("✅ Successfully parsed command JSON\n"); // 解析成功提示
    // 假设原始字符串转换为：
    // {
    //     "command_name": "led_control",
    //     "request_id": "req_123456",
    //     "paras": {
    //         "action": "on",
    //         "target": "all"
    //     }
    // }

    // 提取基本命令信息
    cJSON * command_name_item = cJSON_GetObjectItem(root, "command_name"); // 获取命令名称
    cJSON * request_id_item   = cJSON_GetObjectItem(root, "request_id");   // 获取请求ID
    cJSON * paras_item        = cJSON_GetObjectItem(root, "paras");        // 获取参数对象

    char * command_name = (command_name_item && cJSON_IsString(command_name_item)) ? command_name_item->valuestring
                                                                                   : NULL; // 提取命令名称
    char * request_id =
        (request_id_item && cJSON_IsString(request_id_item)) ? request_id_item->valuestring : NULL; // 提取请求ID

    // 打印命令信息
    printf("📋 Command Info:\n");
    printf("  Command Name: %s\n", command_name ? command_name : "NULL");
    printf("  Request ID: %s\n", request_id ? request_id : "NULL");
    printf("  Parameters Present: %s\n", paras_item ? "YES" : "NO");

    if(!command_name) {                                         // 检查命令名称是否存在
        printf("❌ ERROR: No command_name found in command\n"); // 错误提示
        cJSON_Delete(root);                                     // 释放JSON对象
        return;                                                 // 直接返回
    }

    // 处理不同类型的命令
    if(strcmp(command_name, "buzzer_control") == 0) {               // 蜂鸣器控制命令
        printf("🎵 Processing buzzer_control command\n");           // 处理提示
        handle_buzzer_control_command(paras_item, request_id);      // 调用蜂鸣器控制处理
    } else if(strcmp(command_name, "led_control") == 0) {           // LED控制命令
        printf("💡 Processing led_control command\n");              // 处理提示
        handle_led_control_command(paras_item, request_id);         // 调用LED控制处理
    } else if(strcmp(command_name, "update_display_data") == 0) {   // 显示数据更新命令
        printf("📊 Processing update_display_data command\n");      // 处理提示
        handle_update_display_data_command(paras_item, request_id); // 调用显示数据更新处理
    } else {                                                        // 未知命令
        printf("❌ ERROR: Unknown command: %s\n", command_name);    // 错误提示
        if(request_id) {
            network_send_command_response(request_id, "error", "Unknown command"); // 发送错误响应
        }
    }

    cJSON_Delete(root);                                // 释放JSON对象内存
    printf("=== COMMAND PROCESSING COMPLETE ===\n\n"); // 命令处理完成
}

// 保持原有的generate_simulated_data函数
void generate_simulated_data(parking_data_t * data)
{
    static int counter = 0;                                            // 静态计数器，记录生成次数
    printf("=== Generating simulated data (round %d) ===\n", counter); // 生成提示

    // 先清零整个结构体
    memset(data, 0, sizeof(parking_data_t)); // 清零目标结构体

    // 获取当前数据作为基础
    pthread_mutex_lock(&data_mutex);            // 加锁保护共享数据
    parking_data_t current_data = parking_data; // 复制当前数据
    pthread_mutex_unlock(&data_mutex);          // 解锁

    // 基础停车数据波动
    data->total_spaces = current_data.total_spaces; // 保持总车位数不变

    int change             = (rand() % 11) - 5;                      // 生成-5到+5的随机变化
    data->available_spaces = current_data.available_spaces + change; // 应用变化

    // 边界检查
    if(data->available_spaces < 0) data->available_spaces = 0;                                   // 确保不小于0
    if(data->available_spaces > data->total_spaces) data->available_spaces = data->total_spaces; // 确保不超过总数

    // 计算衍生数据
    data->occupied_spaces  = data->total_spaces - data->available_spaces;        // 计算已用车位
    data->utilization_rate = (data->occupied_spaces * 100) / data->total_spaces; // 计算利用率

    // 环境数据波动
    data->temperature = current_data.temperature + (rand() % 5 - 2); // 温度变化±2度
    if(data->temperature < 15) data->temperature = 15;               // 温度下限15度
    if(data->temperature > 35) data->temperature = 35;               // 温度上限35度

    data->humidity = current_data.humidity + (rand() % 11 - 5); // 湿度变化±5%
    if(data->humidity < 30) data->humidity = 30;                // 湿度下限30%
    if(data->humidity > 80) data->humidity = 80;                // 湿度上限80%

    data->light_level = current_data.light_level + (rand() % 101 - 50); // 光照变化±50
    if(data->light_level < 300) data->light_level = 300;                // 光照下限300
    if(data->light_level > 800) data->light_level = 800;                // 光照上限800

    data->air_quality = 50 + (rand() % 51); // 空气质量50-100随机

    // 车辆进出统计（每12次更新一次）
    if(counter % 12 == 0) {
        int in_change          = rand() % 5 + 1;                         // 进场变化1-5辆
        int out_change         = rand() % 5 + 1;                         // 出场变化1-5辆
        data->vehicles_in      = current_data.vehicles_in + in_change;   // 更新进场数
        data->vehicles_out     = current_data.vehicles_out + out_change; // 更新出场数
        data->vehicles_current = data->vehicles_in - data->vehicles_out; // 计算当前在场数
        if(data->vehicles_current < 0) data->vehicles_current = 0;       // 确保不小于0
    } else {
        // 保持原有数据不变
        data->vehicles_in      = current_data.vehicles_in;
        data->vehicles_out     = current_data.vehicles_out;
        data->vehicles_current = current_data.vehicles_current;
    }

    // 时间戳
    data->timestamp = (int64_t)time(NULL); // 当前时间戳

    // 判断是否高峰时段
    time_t now           = data->timestamp;                                                 // 获取当前时间
    struct tm * tm_info  = localtime(&now);                                                 // 转换为本地时间结构
    int hour             = tm_info->tm_hour;                                                // 提取小时
    data->peak_hour_flag = ((hour >= 8 && hour < 10) || (hour >= 16 && hour < 18)) ? 1 : 0; // 判断高峰时段

    // 楼层数据（使用固定总数，模拟可用车位变化）
    data->floor_b1_total     = 200;                                                             // 地下1层固定200个车位
    data->floor_b1_available = data->floor_b1_total * (100 - 75 + (rand() % 11 - 5)) / 100;     // 模拟可用车位
    if(data->floor_b1_available < 0) data->floor_b1_available = 0;                              // 确保不小于0
    data->floor_b1_utilization = 100 - (data->floor_b1_available * 100 / data->floor_b1_total); // 计算利用率

    data->floor_b2_total     = 150;                                                             // 地下2层固定150个车位
    data->floor_b2_available = data->floor_b2_total * (100 - 60 + (rand() % 11 - 5)) / 100;     // 模拟可用车位
    if(data->floor_b2_available < 0) data->floor_b2_available = 0;                              // 确保不小于0
    data->floor_b2_utilization = 100 - (data->floor_b2_available * 100 / data->floor_b2_total); // 计算利用率

    data->floor_b3_total     = 150;                                                             // 地下3层固定150个车位
    data->floor_b3_available = data->floor_b3_total * (100 - 85 + (rand() % 11 - 5)) / 100;     // 模拟可用车位
    if(data->floor_b3_available < 0) data->floor_b3_available = 0;                              // 确保不小于0
    data->floor_b3_utilization = 100 - (data->floor_b3_available * 100 / data->floor_b3_total); // 计算利用率

    // 客户行为分析数据波动
    data->avg_parking_time_x100 = 250 + (rand() % 21 - 10) * 10;  // 平均停车时间变化
    data->avg_consumption_x100  = 4560 + (rand() % 21 - 10) * 50; // 平均消费金额变化
    data->member_ratio          = 68 + (rand() % 11 - 5);         // 会员比例变化

    // 停车时长分布（保持总和100%）
    int base_less_1h = 35 + (rand() % 11 - 5); // <1小时基础值
    int base_1_2h    = 20 + (rand() % 11 - 5); // 1-2小时基础值
    int base_2_4h    = 20 + (rand() % 11 - 5); // 2-4小时基础值
    int base_more_4h = 25 + (rand() % 11 - 5); // >4小时基础值

    int total_base = base_less_1h + base_1_2h + base_2_4h + base_more_4h; // 计算总和

    // 转换为百分比
    data->parking_time_less_1h = (base_less_1h * 100) / total_base;
    data->parking_time_1_2h    = (base_1_2h * 100) / total_base;
    data->parking_time_2_4h    = (base_2_4h * 100) / total_base;
    data->parking_time_more_4h = (base_more_4h * 100) / total_base;

    // 车牌识别数据 - 确保这些字段有变化
    data->recognized_vehicles    = +(rand() % 100);     // 0-100 之间变化
    data->unrecognized_rate_x100 = 200 + (rand() % 60); // 2.0%-2.6% 之间变化

    // 车辆类型分布（保持总和100%）
    int base_truck = 45 + (rand() % 11 - 5); // 货车基础值
    int base_suv   = 30 + (rand() % 11 - 5); // SUV基础值
    int base_car   = 25 + (rand() % 11 - 5); // 轿车基础值

    int total_vehicle_base = base_truck + base_suv + base_car; // 计算总和

    // 转换为百分比
    data->vehicle_type_truck = (base_truck * 100) / total_vehicle_base;
    data->vehicle_type_suv   = (base_suv * 100) / total_vehicle_base;
    data->vehicle_type_car   = (base_car * 100) / total_vehicle_base;

    // 客户反馈数据
    strncpy(data->common_feedback, "车位不足", sizeof(data->common_feedback) - 1); // 固定反馈内容
    data->common_feedback[sizeof(data->common_feedback) - 1] = '\0';               // 确保字符串结束

    // 评分数据波动
    data->avg_waiting_time_x100 = 850 + (rand() % 11 - 5) * 10; // 平均等待时间变化
    data->facility_score_x100   = 450 + (rand() % 11 - 5) * 10; // 设施评分变化
    data->service_score_x100    = 430 + (rand() % 11 - 5) * 10; // 服务评分变化
    data->satisfaction_score    = 90 + (rand() % 11 - 5);       // 满意度变化

    // 高峰时段数据波动
    data->hour_6_count  = 20 + (rand() % 11 - 5);   // 6点车流量变化
    data->hour_8_count  = 120 + (rand() % 21 - 10); // 8点车流量变化
    data->hour_10_count = 80 + (rand() % 21 - 10);  // 10点车流量变化
    data->hour_12_count = 40 + (rand() % 11 - 5);   // 12点车流量变化
    data->hour_14_count = 60 + (rand() % 11 - 5);   // 14点车流量变化
    data->hour_16_count = 100 + (rand() % 21 - 10); // 16点车流量变化
    data->hour_18_count = 130 + (rand() % 21 - 10); // 18点车流量变化
    data->hour_20_count = 70 + (rand() % 11 - 5);   // 20点车流量变化

    // 确保数据真的有变化
    // data->available_spaces = 300 + (rand() % 50); // 确保在300-350之间变化
    // data->temperature = 20 + (rand() % 15);       // 确保在20-35之间变化

    // 打印生成的关键数据
    // printf("Generated: available=%d, temp=%d\n", data->available_spaces, data->temperature);
    counter++; // 增加计数器

    // 添加数据验证
    // printf("Generated data verification:\n");
    // printf("  total=%d, available=%d, utilization=%d%%\n", data->total_spaces, data->available_spaces,
    // data->utilization_rate); printf("  temperature=%d, humidity=%d%%\n", data->temperature, data->humidity); printf("
    // floor utilization: B1=%d%%, B2=%d%%, B3=%d%%\n", data->floor_b1_utilization, data->floor_b2_utilization,
    // data->floor_b3_utilization);
}

// 保持原有的validate_parking_data函数
void validate_parking_data(const parking_data_t * data)
{
    // 数据验证输出
    printf("=== Data Validation ===\n");
    printf("Total spaces: %d\n", data->total_spaces);
    printf("Available spaces: %d\n", data->available_spaces);
    printf("Occupied spaces: %d\n", data->occupied_spaces);
    printf("Utilization rate: %d%%\n", data->utilization_rate);
    printf("Timestamp: %" PRId64 "\n", data->timestamp);
    printf("Common feedback: %s\n", data->common_feedback);
    printf("=== End Validation ===\n");

    // 数据有效性检查
    if(data->total_spaces <= 0) {
        printf("WARNING: Invalid total_spaces: %d\n", data->total_spaces); // 总车位数无效警告
    }
    if(data->available_spaces < 0 || data->available_spaces > data->total_spaces) {
        printf("WARNING: Invalid available_spaces: %d (total: %d)\n", data->available_spaces,
               data->total_spaces); // 可用车位数无效警告
    }
}